{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上一节基本完成了FFM，这一节对其损失函数做扩展，让它能支持更多的任务，由链式求导，我们知道：\n",
    "\n",
    "$$\n",
    "\\frac{\\partial L(\\theta)}{\\partial \\theta}=\\frac{\\partial L(\\theta)}{\\partial y(x)}\\frac{\\partial y(x)}{\\partial\\theta}\n",
    "$$\n",
    "\n",
    "其中，$\\frac{\\partial y(x)}{\\partial\\theta}$对所有任务都一样，由上一节的推导我们知道：   \n",
    "\n",
    "$$\n",
    "\\frac{\\partial y(x)}{\\partial\\theta}=\\left\\{\\begin{matrix}\n",
    "1 &\\theta=w_0 \\\\ \n",
    "x_i &\\theta=w_i \\\\ \n",
    "v_{j,f_i,l}x_ix_j & \\theta=v_{i,f_j,l}\n",
    "\\end{matrix}\\right.\n",
    "$$  \n",
    "\n",
    "所以，我们只需要根据不同的任务求解$\\frac{\\partial L(\\theta)}{\\partial y(x)}$即可，对于最小二乘回归，我们上一节已经推导了$\\frac{\\partial L(\\theta)}{\\partial y(x)}=y(x)-t$，接下来回顾一下其他几种损失函数的梯度\n",
    "### 一.回归任务扩展\n",
    "回归任务的更多梯度求解在[《10_12_集成学习_xgboost_回归的更多实现：泊松回归、gamma回归、tweedie回归》](https://nbviewer.jupyter.org/github/zhulei227/ML_Notes/blob/master/notebooks/10_12_%E9%9B%86%E6%88%90%E5%AD%A6%E4%B9%A0_xgboost_%E5%9B%9E%E5%BD%92%E7%9A%84%E6%9B%B4%E5%A4%9A%E5%AE%9E%E7%8E%B0%EF%BC%9A%E6%B3%8A%E6%9D%BE%E5%9B%9E%E5%BD%92%E3%80%81gamma%E5%9B%9E%E5%BD%92%E3%80%81tweedie%E5%9B%9E%E5%BD%92.ipynb)中已经做推导，下面再列一下  \n",
    "\n",
    "#### possion回归\n",
    "$$\n",
    "\\frac{\\partial L(\\theta)}{\\partial y(x)}=e^{y(x)}-t\n",
    "$$\n",
    "#### gamma回归\n",
    "$$\n",
    "\\frac{\\partial L(\\theta)}{\\partial y(x)}=1-te^{-y(x)}\n",
    "$$\n",
    "#### tweedie回归\n",
    "$$\n",
    "\\frac{\\partial L(\\theta)}{\\partial y(x)}=\\left\\{\\begin{matrix}\n",
    "e^{y(x)}-t & p=1\\\\ \n",
    "1-te^{-y(x)} &p=2\\\\ \n",
    "(2-p)e^{y(x)(2-p)}-(1-p)te^{y(x)(1-p)} & p\\neq 1,p\\neq 2 \n",
    "\\end{matrix}\\right.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 二.分类任务扩展\n",
    "对于二分类任务，我们参考[《02_线性模型_逻辑回归》](https://nbviewer.jupyter.org/github/zhulei227/ML_Notes/blob/master/notebooks/02_%E7%BA%BF%E6%80%A7%E6%A8%A1%E5%9E%8B_%E9%80%BB%E8%BE%91%E5%9B%9E%E5%BD%92.ipynb)中的推导，即相对线性模型套一个sigmoid函数，然后损失函数取交叉熵\n",
    "\n",
    "#### 二分类\n",
    "\n",
    "$$\n",
    "\\frac{\\partial L(\\theta)}{\\partial y(x)}=\\sigma(y(x))-t\n",
    "$$  \n",
    "\n",
    "这里，$\\sigma(\\cdot)$即是sigmoid函数  \n",
    "\n",
    "#### 多分类\n",
    "\n",
    "多分类的任务实现，可以参考[《10_06_集成学习_boosting_gbm_classifier》](https://nbviewer.jupyter.org/github/zhulei227/ML_Notes/blob/master/notebooks/10_06_%E9%9B%86%E6%88%90%E5%AD%A6%E4%B9%A0_boosting_gbm_classifier.ipynb)，即独立训练多个FFM模型方程，然后对它们做softmax然后取交叉熵，但这里就偷个懒不去实现了，可以利用[《03_二分类转多分类的一般实现》](https://nbviewer.jupyter.org/github/zhulei227/ML_Notes/blob/master/notebooks/03_%E4%BA%8C%E5%88%86%E7%B1%BB%E8%BD%AC%E5%A4%9A%E5%88%86%E7%B1%BB%E7%9A%84%E4%B8%80%E8%88%AC%E5%AE%9E%E7%8E%B0.ipynb)中的方法，通过ovo或者ovr的方式来将二分类问题转化为多分类问题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 三.代码实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "FFM因子分解机的实现\n",
    "\"\"\"\n",
    "import os\n",
    "os.chdir('../')\n",
    "import numpy as np\n",
    "from ml_models import utils\n",
    "\n",
    "\n",
    "class FFM(object):\n",
    "    def __init__(self, epochs=1, lr=1e-3, adjust_lr=True, batch_size=1, hidden_dim=4, lamb=1e-3, alpha=1e-3,\n",
    "                 normal=True, solver='adam', rho_1=0.9, rho_2=0.999, early_stopping_rounds=100,\n",
    "                 objective=\"squarederror\", tweedie_p=1.5):\n",
    "        \"\"\"\n",
    "\n",
    "        :param epochs: 迭代轮数\n",
    "        :param lr: 学习率\n",
    "        :param adjust_lr:是否根据特征数量再次调整学习率 max(lr,1/n_feature)\n",
    "        :param batch_size:\n",
    "        :param hidden_dim:隐变量维度\n",
    "        :param lamb:l2正则项系数\n",
    "        :param alpha:l1正则项系数\n",
    "        :param normal:是否归一化，默认用min-max归一化\n",
    "        :param solver:优化方式，包括sgd,adam,默认adam\n",
    "        :param rho_1:adam的rho_1的权重衰减,solver=adam时生效\n",
    "        :param rho_2:adam的rho_2的权重衰减,solver=adam时生效\n",
    "        :param early_stopping_rounds:对early_stopping进行支持，默认100，使用rmse作为回归任务评估指标，使用错误率（1-accuray）作为分类任务的评估指标\n",
    "        :param objective:损失函数，回归任务支持squarederror,poisson,gamma,tweedie，分类任务支持logistic\n",
    "        :param tweedie_p:teweedie的超参数，objective=tweedie时生效\n",
    "        \"\"\"\n",
    "        self.epochs = epochs\n",
    "        self.lr = lr\n",
    "        self.adjust_lr = adjust_lr\n",
    "        self.batch_size = batch_size\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.lamb = lamb\n",
    "        self.alpha = alpha\n",
    "        self.solver = solver\n",
    "        self.rho_1 = rho_1\n",
    "        self.rho_2 = rho_2\n",
    "        self.early_stopping_rounds = early_stopping_rounds\n",
    "        self.objective = objective\n",
    "        self.tweedie_p = tweedie_p\n",
    "        # 初始化参数\n",
    "        self.w = None  # w_0,w_i\n",
    "        self.V = None  # v_{i,f}\n",
    "        # 归一化\n",
    "        self.normal = normal\n",
    "        if normal:\n",
    "            self.xmin = None\n",
    "            self.xmax = None\n",
    "        # 功能性参数\n",
    "        self.replace_ind = None  # 置换index\n",
    "        self.positive_ind = None  # 参与特征组合的开始id\n",
    "        self.fields = []  # replace_ind后的fields\n",
    "        self.field_num = None\n",
    "\n",
    "    def _y(self, X):\n",
    "        \"\"\"\n",
    "        实现y(x)的功能\n",
    "        :param X:\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        # 去掉第一列bias以及非组合特征\n",
    "        X_ = X[:, self.positive_ind + 1:]\n",
    "        n_sample, n_feature = X_.shape\n",
    "        pol = np.zeros(n_sample)\n",
    "        for i in range(0, n_feature - 1):\n",
    "            for j in range(i + 1, n_feature):\n",
    "                pol += X_[:, i] * X_[:, j] * np.dot(self.V[i, self.fields[self.positive_ind + j]],\n",
    "                                                    self.V[j, self.fields[self.positive_ind + i]])\n",
    "        linear_rst = X @ self.w.reshape(-1) + pol\n",
    "        return linear_rst\n",
    "\n",
    "    def fit(self, X, y, eval_set=None, show_log=False, fields=None):\n",
    "        \"\"\"\n",
    "        :param X:\n",
    "        :param y:\n",
    "        :param eval_set:\n",
    "        :param show_log:\n",
    "        :param fields: 为None时，退化为FM\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        X_o = X.copy()\n",
    "\n",
    "        # 归一化\n",
    "        if self.normal:\n",
    "            self.xmin = X.min(axis=0)\n",
    "            self.xmax = X.max(axis=0)\n",
    "            X = (X - self.xmin) / self.xmax\n",
    "\n",
    "        n_sample, n_feature = X.shape\n",
    "        # 处理fields\n",
    "        if fields is None:\n",
    "            self.replace_ind = list(range(0, n_feature))\n",
    "            self.positive_ind = 0\n",
    "            self.fields = [0] * n_feature\n",
    "            self.field_num = 1\n",
    "        else:\n",
    "            self.replace_ind = np.argsort(fields).tolist()\n",
    "            self.positive_ind = np.sum([1 if item < 0 else 0 for item in fields])\n",
    "            self.fields = sorted(fields)\n",
    "            self.field_num = len(set(self.fields[self.positive_ind:]))\n",
    "\n",
    "        # reshape X\n",
    "        X = X[:, self.replace_ind]\n",
    "\n",
    "        x_y = np.c_[np.ones(n_sample), X, y]\n",
    "        # 记录loss\n",
    "        train_losses = []\n",
    "        eval_losses = []\n",
    "        # 调整一下学习率\n",
    "        if self.adjust_lr:\n",
    "            self.lr = max(self.lr, 1 / n_feature)\n",
    "        # 初始化参数\n",
    "        self.w = np.random.random((n_feature + 1, 1)) * 1e-3\n",
    "        self.V = np.random.random((n_feature - self.positive_ind, self.field_num, self.hidden_dim)) * 1e-3\n",
    "        if self.solver == 'adam':\n",
    "            # 缓存梯度一阶，二阶估计\n",
    "            w_1 = np.zeros_like(self.w)\n",
    "            V_1 = np.zeros_like(self.V)\n",
    "            w_2 = np.zeros_like(self.w)\n",
    "            V_2 = np.zeros_like(self.V)\n",
    "        # 更新参数\n",
    "        count = 0\n",
    "        for epoch in range(self.epochs):\n",
    "            # 验证集记录\n",
    "            best_eval_value = np.power(2., 1023)\n",
    "            eval_count = 0\n",
    "            np.random.shuffle(x_y)\n",
    "            for index in range(x_y.shape[0] // self.batch_size):\n",
    "                count += 1\n",
    "                batch_x_y = x_y[self.batch_size * index:self.batch_size * (index + 1)]\n",
    "                batch_x = batch_x_y[:, :-1]\n",
    "                batch_y = batch_x_y[:, -1:]\n",
    "                # 计算链式求导第一层梯度\n",
    "                if self.objective == \"squarederror\":\n",
    "                    y_x_t = self._y(batch_x).reshape((-1, 1)) - batch_y\n",
    "                elif self.objective == \"poisson\":\n",
    "                    y_x_t = np.exp(self._y(batch_x).reshape((-1, 1))) - batch_y\n",
    "                elif self.objective == \"gamma\":\n",
    "                    y_x_t = 1.0 - batch_y * np.exp(-1.0 * self._y(batch_x).reshape((-1, 1)))\n",
    "                elif self.objective == 'tweedie':\n",
    "                    if self.tweedie_p == 1:\n",
    "                        y_x_t = np.exp(self._y(batch_x).reshape((-1, 1))) - batch_y\n",
    "                    elif self.tweedie_p == 2:\n",
    "                        y_x_t = 1.0 - batch_y * np.exp(-1.0 * self._y(batch_x).reshape((-1, 1)))\n",
    "                    else:\n",
    "                        y_x_t = np.exp(self._y(batch_x).reshape((-1, 1)) * (2.0 - self.tweedie_p)) \\\n",
    "                                - batch_y * np.exp(self._y(batch_x).reshape((-1, 1)) * (1.0 - self.tweedie_p))\n",
    "                else:\n",
    "                    # 二分类\n",
    "                    y_x_t = utils.sigmoid(self._y(batch_x).reshape((-1, 1))) - batch_y\n",
    "\n",
    "                # 更新w\n",
    "                if self.solver == 'sgd':\n",
    "                    self.w = self.w - (self.lr * (np.sum(y_x_t * batch_x, axis=0) / self.batch_size).reshape(\n",
    "                        (-1, 1)) + self.lamb * self.w + self.alpha * np.where(self.w > 0, 1, 0))\n",
    "                elif self.solver == 'adam':\n",
    "                    w_reg = self.lamb * self.w + self.alpha * np.where(self.w > 0, 1, 0)\n",
    "                    w_grad = (np.sum(y_x_t * batch_x, axis=0) / self.batch_size).reshape(\n",
    "                        (-1, 1)) + w_reg\n",
    "                    w_1 = self.rho_1 * w_1 + (1 - self.rho_1) * w_grad\n",
    "                    w_2 = self.rho_2 * w_2 + (1 - self.rho_2) * w_grad * w_grad\n",
    "                    w_1_ = w_1 / (1 - np.power(self.rho_1, count))\n",
    "                    w_2_ = w_2 / (1 - np.power(self.rho_2, count))\n",
    "                    self.w = self.w - (self.lr * w_1_) / (np.sqrt(w_2_) + 1e-8)\n",
    "\n",
    "                # 更新 V\n",
    "                batch_x_ = batch_x[:, 1 + self.positive_ind:]\n",
    "                # 逐元素更新\n",
    "                for i in range(0, batch_x_.shape[1] - 1):\n",
    "                    for j in range(i + 1, batch_x_.shape[1]):\n",
    "                        for k in range(0, self.hidden_dim):\n",
    "                            v_reg_l = self.lamb * self.V[i, self.fields[self.positive_ind + j], k] + \\\n",
    "                                      self.alpha * (self.V[i, self.fields[self.positive_ind + j], k] > 0)\n",
    "\n",
    "                            v_grad_l = np.sum(y_x_t.reshape(-1) * batch_x_[:, i] * batch_x_[:, j] *\n",
    "                                              self.V[\n",
    "                                                  j, self.fields[self.positive_ind + i], k]) / self.batch_size + v_reg_l\n",
    "\n",
    "                            v_reg_r = self.lamb * self.V[j, self.fields[self.positive_ind + i], k] + \\\n",
    "                                      self.alpha * (self.V[j, self.fields[self.positive_ind + i], k] > 0)\n",
    "\n",
    "                            v_grad_r = np.sum(y_x_t.reshape(-1) * batch_x_[:, i] * batch_x_[:, j] *\n",
    "                                              self.V[\n",
    "                                                  i, self.fields[self.positive_ind + j], k]) / self.batch_size + v_reg_r\n",
    "\n",
    "                            if self.solver == \"sgd\":\n",
    "                                self.V[i, self.fields[self.positive_ind + j], k] -= self.lr * v_grad_l\n",
    "                                self.V[j, self.fields[self.positive_ind + i], k] -= self.lr * v_grad_r\n",
    "                            elif self.solver == \"adam\":\n",
    "                                V_1[i, self.fields[self.positive_ind + j], k] = self.rho_1 * V_1[\n",
    "                                    i, self.fields[self.positive_ind + j], k] + (1 - self.rho_1) * v_grad_l\n",
    "                                V_2[i, self.fields[self.positive_ind + j], k] = self.rho_2 * V_2[\n",
    "                                    i, self.fields[self.positive_ind + j], k] + (1 - self.rho_2) * v_grad_l * v_grad_l\n",
    "                                v_1_l = V_1[i, self.fields[self.positive_ind + j], k] / (\n",
    "                                    1 - np.power(self.rho_1, count))\n",
    "                                v_2_l = V_2[i, self.fields[self.positive_ind + j], k] / (\n",
    "                                    1 - np.power(self.rho_2, count))\n",
    "\n",
    "                                V_1[j, self.fields[self.positive_ind + i], k] = self.rho_1 * V_1[\n",
    "                                    j, self.fields[self.positive_ind + i], k] + (1 - self.rho_1) * v_grad_r\n",
    "                                V_2[j, self.fields[self.positive_ind + i], k] = self.rho_2 * V_2[\n",
    "                                    j, self.fields[self.positive_ind + i], k] + (1 - self.rho_2) * v_grad_r * v_grad_r\n",
    "                                v_1_r = V_1[j, self.fields[self.positive_ind + i], k] / (\n",
    "                                    1 - np.power(self.rho_1, count))\n",
    "                                v_2_r = V_2[j, self.fields[self.positive_ind + i], k] / (\n",
    "                                    1 - np.power(self.rho_2, count))\n",
    "\n",
    "                                self.V[i, self.fields[self.positive_ind + j], k] -= (self.lr * v_1_l) / (\n",
    "                                    np.sqrt(v_2_l) + 1e-8)\n",
    "\n",
    "                                self.V[j, self.fields[self.positive_ind + i], k] -= (self.lr * v_1_r) / (\n",
    "                                    np.sqrt(v_2_r) + 1e-8)\n",
    "\n",
    "                # 计算eval loss\n",
    "                eval_loss = None\n",
    "                if eval_set is not None:\n",
    "                    eval_x, eval_y = eval_set\n",
    "                    if self.objective == 'logistic':\n",
    "                        eval_loss = np.mean(eval_y != self.predict(eval_x))\n",
    "                    else:\n",
    "                        eval_loss = np.std(eval_y - self.predict(eval_x))\n",
    "                    eval_losses.append(eval_loss)\n",
    "                # 是否显示\n",
    "                if show_log:\n",
    "                    if self.objective == 'logistic':\n",
    "                        train_loss = np.mean(y != self.predict(X_o))\n",
    "                    else:\n",
    "                        train_loss = np.std(y - self.predict(X_o))\n",
    "                    print(\"epoch:\", epoch + 1, \"/\", self.epochs, \",samples:\", (index + 1) * self.batch_size, \"/\",\n",
    "                          n_sample,\n",
    "                          \",train loss:\",\n",
    "                          train_loss, \",eval loss:\", eval_loss)\n",
    "                    train_losses.append(train_loss)\n",
    "                # 是否早停\n",
    "                if eval_loss is not None and self.early_stopping_rounds is not None:\n",
    "                    if eval_loss < best_eval_value:\n",
    "                        eval_count = 0\n",
    "                        best_eval_value = eval_loss\n",
    "                    else:\n",
    "                        eval_count += 1\n",
    "                    if eval_count >= self.early_stopping_rounds:\n",
    "                        print(\"---------------early_stopping-----------------------------\")\n",
    "                        break\n",
    "\n",
    "        return train_losses, eval_losses\n",
    "\n",
    "    def predict_proba(self, X):\n",
    "        \"\"\"\n",
    "        logistic regression用\n",
    "        :param X:\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        # 归一化\n",
    "        if self.normal:\n",
    "            X = (X - self.xmin) / self.xmax\n",
    "        # reshape\n",
    "        X = X[:, self.replace_ind]\n",
    "        # 去掉第一列bias以及非组合特征\n",
    "        X_ = X[:, self.positive_ind:]\n",
    "        n_sample, n_feature = X_.shape\n",
    "        pol = np.zeros(n_sample)\n",
    "        for i in range(0, n_feature - 1):\n",
    "            for j in range(i + 1, n_feature):\n",
    "                pol += X_[:, i] * X_[:, j] * np.dot(self.V[i, self.fields[self.positive_ind + j]],\n",
    "                                                    self.V[j, self.fields[self.positive_ind + i]])\n",
    "        pos_proba = utils.sigmoid(np.c_[np.ones(n_sample), X] @ self.w.reshape(-1) + pol)\n",
    "        return np.c_[1.0-pos_proba,pos_proba]\n",
    "\n",
    "    def predict(self, X):\n",
    "        \"\"\"\n",
    "        :param X:\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        # 归一化\n",
    "        if self.normal:\n",
    "            X = (X - self.xmin) / self.xmax\n",
    "        # reshape\n",
    "        X = X[:, self.replace_ind]\n",
    "        # 去掉第一列bias以及非组合特征\n",
    "        X_ = X[:, self.positive_ind:]\n",
    "        n_sample, n_feature = X_.shape\n",
    "        pol = np.zeros(n_sample)\n",
    "        for i in range(0, n_feature - 1):\n",
    "            for j in range(i + 1, n_feature):\n",
    "                pol += X_[:, i] * X_[:, j] * np.dot(self.V[i, self.fields[self.positive_ind + j]],\n",
    "                                                    self.V[j, self.fields[self.positive_ind + i]])\n",
    "\n",
    "        linear_rst = np.c_[np.ones(n_sample), X] @ self.w.reshape(-1) + pol\n",
    "        if self.objective == \"squarederror\":\n",
    "            return linear_rst\n",
    "        elif self.objective in [\"poisson\", \"gamma\", \"tweedie\"]:\n",
    "            return np.exp(linear_rst)\n",
    "        else:\n",
    "            return utils.sigmoid(linear_rst) > 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 四.测试"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 回归测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#造伪数据\n",
    "data1 = np.linspace(1, 10, num=100)\n",
    "data2 = np.linspace(1, 10, num=100) + np.random.random(size=100)\n",
    "data3 = np.linspace(10, 1, num=100)\n",
    "target = data1 * 2 + data3 * 0.1 + data2 * 1 + 10 * data1 * data2 + np.random.random(size=100)\n",
    "data = np.c_[data1, data2, data3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(data, target, test_size=0.4, random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### squarederror"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1f0a7ad1550>]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD8CAYAAAB+UHOxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3Xl8Tdf6+PHPkwEhiDEkhhhjLhWzqplWew2ldPhWR723M7du6agjvenvtno7amn1UrSaBlVibA0lhKggiVklMQQ5ghwyrd8fZ5AQY4aT5Dzv18vr5Oy99t5LXqxn72etvZYYY1BKKeV+PFxdAaWUUq6hAUAppdyUBgCllHJTGgCUUspNaQBQSik3pQFAKaXclAYApZRyUxoAlFLKTWkAUEopN+Xl6gpcTfXq1U1QUJCrq6GUUiXKli1bThhjalyrXLEOAEFBQURFRbm6GkopVaKIyKHrKacpIKWUclMaAJRSyk1pAFBKKTelAUAppdyUBgCllHJTGgCUUspNFethoEop5Q7CoxMJjYgnyWKlso83ImBJyyDAz4fxA4IZ0i6wUK6rTwBKKeVC4dGJvDp/G31W/kD3A1uxpp4lJS0DAyRarEwMiyE8OrFQrq1PAEop5UKhEfF0jd3AWyu+BOC8Vxk21WnJp13uJbJea6wZWYRGxBfKU4A+ASillAslWax0P7iNc97leGT4G8xqewe1zpzEKzsrV5nCoE8ASinlQgF+PnQ/GE1k3VasbtSB1Y062HYYk6tMYdAAoJRSRSBnR2/Ozt3XW1egYUoSs9oNyn2ACAA+3p6MHxBcKHXSAKCUUoUsPDqRiWExWDNsaR1H5y7AkKM7ANjdpjMCRToKSAOAUkoVstCIeKwZWQQnH2Ti6m8Ye9c4UspXtnXublsOAQHM+s8jzrv+oqKdwEopVcgcnbiPbl5AzwNbeGbDDwAcSTkHK1dC375F3viDBgCllCp0AX4+lMs4z53x67jg6cWD0YsJPH2c29MS4cQJ6NfPJfXSAKCUUoVs/IBgBu3fTMV0KxMGPocRD8atm0VwTCQAS2q2cEm9tA9AKaUKkGO0z5GUc9SuUsHZidvl2EaO+tUkvGVPmiUf5IlNP3OwSm3iqtdn3NrjXKiRWGidvVeiTwBKKVVAHKN9uq5ZyMZPR1N23x4mhsWwdNkW/CPXUuvpJwioUoHPOo/gTNnyNExJYl1QW+fbvkVNA4BSShUQx2ifzodjqHkuhRnz38Tn9Cm2TP4MsrNZ0b4/SRYrp30q8kXn4QCsbXArUHhv+17NNQOAiMwQkeMisiPHtqoislxE9tg/q9i3i4h8LCJ7RWS7iNya45jR9vJ7RGR04fx1lFLKdRyNeKOThznkV4taZ08yLewdhu9YQXTtYJ7dmoZfeW8AvuowlMfueY3f7QGgsN72vZrreQL4Fhh4ybYJwEpjTBNgpf07wB1AE/ufMcDnYAsYwBtAJ6Aj8IYjaCilVGkR4OcDxtD4ZAKrGnVg7KBxhCTGEnziL35q3QdrRhbG2N7uzfT0YmXjTiBSqG/7Xs01A4AxZg1w6pLNg4GZ9p9nAkNybP/O2GwE/ESkNjAAWG6MOWWMSQGWc3lQUUqpEm38gGAaWFPwTbeyr1pdljTrztu9H2df1UAWNbsNgNPWDCYPa02gnw8CBPr5MHlY6yLvAIabHwXkb4w5AmCMOSIiNe3bA4HDOcol2LddabtSSpUaQ9oFUmODJwB7qtUFYHqHIUwPGex80SvAz4ch7QJd0uBfqqA7gfN6lc1cZfvlJxAZIyJRIhKVnJxcoJVTSqnC1i39OACjH7sDH29bMCiKid1uxs0GgGP21A72z+P27QlA3Rzl6gBJV9l+GWPMNGNMiDEmpEaNGjdZPaWUcpHYWKhWjTt7tyk2qZ4rudkU0EJgNDDF/rkgx/ZnRGQutg7f0/YUUQTwXo6O3/7AxJuvtlJKFVOxsdC8OYgUm1TPlVwzAIjIHKAnUF1EErCN5pkC/CAijwF/ASPsxX8F7gT2AmnAIwDGmFMi8jaw2V7uLWPMpR3LSilV8u3aBcOGuboW1+WaAcAYc98VdvXJo6wBnr7CeWYAM26odkopVZIkJ8PJk9DCNXP73Ch9E1gppQpKbKzts3lz19bjOmkAUEqpgrJrl+1TA4BSSrmZ2Fjw9YW6da9dthjQ6aCVUuom5LnIe2wsNGvmktW9boY+ASil1A1yTPucaLFiuLjIu/XPmBKT/gENAEopdcMc0z7n5Hn2DD7Hj/L58bKERye6qGY3RlNASil1g5IsVjCGV1d9TfvEON7u/ThZHrb76a0VarEuLAagWL8EBhoAlFLqujny/gZ4Yf33PB61gNQy5QmbPZ4d/o0A2yRwjhW+NAAopVQxlWdH7hUabUfe35qRxQPRv/LC+jnMa92PN/uO4bn1c3h8czjnvcpw2K8W4JoVvm6UBgCllFsKj07k5Z/+5N/zJ7OoRQ8imnZl4lVSN468/4D4P3hr+ResaNSBlwc+Q5aHJ1N6Pcr81n2pak0ly8M2A6grVvi6URoAlFJuKTQinhYHd3BX/DrKZqUT0bRrnqkbx1NCosVKvz0b+WTh+2yr3ZRnBr/kbOx9vD3ZW72e85jiNu3zlegoIKWUW0qyWBmy8zcA2ifGgTHO7Q45h3v2372Bz8Ins8O/MQ/f+ybnvcsBF6d5Ls7TPl+JPgEopdxSPV8vBsWt40wZH6paU2l0KoF91ermSt040j5990Ty6YIpxNRqzOh73+JM2QrAxTv94j7t85XoE4BSyi2973uEKufP8FG3+wFonxB7WeomyWKlTGYG70V8QlyNoFyNf0m6078SDQBKKbfUecMSLvhVZUXvEZzyqUSP5N2XNegBfj4MiltLzXMp/Pv20bka//UTepfoxh80BaSUckepqbBwIWUffZTfXx0Am27nrvh4uKRBH9+/KU2njmFPtbqsDWoHlJwO3uuhTwBKKbcSHp3IO4+9C+fPMya7mW3ahq5dYfdu24IuOQw5u58WR/cR1mM4IlIq0j456ROAUsptOEb1fBm1nEN+tVhWqQFrw2KoFtSU2wD++AMGD3YO/Xztm1fpXL4Szcc/xYEujV1d/QKnTwBKKbcRGhGP19lUuh36k0XNe4AI1owsXk/yAW9vWL/eGSQ8Dh6g/+6NzLplIC/9urfETPB2IzQAKKXcRpLFSusje/A02UTWbeXcfvBcNrRvD+vXO4d+Phq1gCwPD/7X7k7nC2KljQYApZTbCPDz4ZajewDYXqtJru17mtxCeuRmTpw4zYPRv/LIlkX83LIXxypWB0rG3D43SgOAUsptjB8QTLtjeznoV5vTPhUB26ieXs1q8LG1BmWyMpiy5GPeWfYZyxt35LX+TzmPLQlz+9wo7QRWSrmNIe0CSbMcYF395gg4ZwANjYjnQi3b0M6hu35jUbPbGHvXP8n0tDWRpWnoZ04aAJRS7uPoUcofTaL/v17kwNhBzs1j523DVKjCkqZdOe5bhTf7jCHbPtFb4DWmiS7JNAAopdzH5s22zw4dcm0O8PMh0WLlH0NfzrXd8cZvaaV9AEop97F5M3h4QLt2uTaPHxCMj7dnrm2lNe2Tkz4BKKXcx6ZN0KoVVKiQa7MjvXO9q4OVFhoAlFLuwRjbE8DQoXnuLqlTOudHvlJAIjJWRHaKyA4RmSMi5USkgYhEisgeEZknImXsZcvav++17w8qiL+AUkpdlwMH4NSpy/L/7uymA4CIBALPASHGmFaAJzAKeB/40BjTBEgBHrMf8hiQYoxpDHxoL6eUUkXjCh3A7iy/ncBegI+IeAHlgSNAb2C+ff9MYIj958H279j39xERyef1lVLqmsKjE5nzyXwueHrTY8mJUjmvz8246T4AY0yiiHwA/AVYgWXAFsBijMm0F0sAHEm1QOCw/dhMETkNVANO3GwdlFLuITw6kQ8X78B3XzyWpi0ZP7DZNfP1ORdzF2DuwVh2+jfkrzMZTAyLAXC7nP+l8pMCqoLtrr4BEABUAO7Io6hxHHKVfTnPO0ZEokQkKvmSubmVUu7HMTvnnSvmsPjb5/li6pMsfeszGry0iG5TVuV5N59zMXeAytZUWh3bx5+1mwKU2sndblR+RgH1BQ4YY5IBRCQM6Ar4iYiX/SmgDpBkL58A1AUS7CmjysCpS09qjJkGTAMICQm5LEAopdyLY3bOPns3kVCpJr7paXwR/h6xNYIYM+xVJoalA7a7+Zx3/QBV0k7z+OZwRm/9BZ+MC6xo3Ml53tI4uduNyk8A+AvoLCLlsaWA+gBRwGpgODAXGA0ssJdfaP++wb5/lTFGG3il1FUlWaxUtp6hXVI8n3S5l4+73ceguLW8tfwL5n0/gfvue48X5mUxaeFOzqVnIhfS6XtgK3fHrqHf3o2Uy0hncbPufNx1FHtq1HeetzRO7naj8tMHECki84GtQCYQje3OfTEwV0TesW+bbj9kOvA/EdmL7c5/VH4qrpRyDwF+PrSLXYOnyeb3hu3J8vBkYYue7Klej9lzX2Xe9xN4YNS7VEs7zdAdqxgUv55KF85xyqcS4S168U37u3M1/OAeb/leDynON+EhISEmKirK1dVQShWR8OhEPlm4jXPHTuBRr66zkc5++BF67d5I+2dnOSdpAwhOPsjsua9QNS0VDwznvMuxtGkXFrboyfr6tzhn8wRbJ6ShdE/u5iAiW4wxIdcqp28CK6WKBUfH7fgl0xi+YyU9x0xjYlg6k4e05M6kP1nbNIRsD09nQw4QXyOIkfdN4R+R81kb1JZlTbpgLVPusnO7Q6N/M3QyOKVUseDo7L3lyG4qXTjHUxt+wJqRRfjMXyl34jj9xo3m4JRBfDiyLYE58vf7qtflxUFjWdCy12WNv4+3Jx+NbMv6Cb218c+DBgClVLGQZLEiJpvgE4fI8PDk/6IXE5B6nJZ//mErMHAgYBvts35Cbz4a2fayGTy9PYQq5b0RbHf9k4e11ob/KjQFpJQqFgL8fJCDB/BNt/Jxl5E8uSmMF9Z9T9Mzx+DWW8HfP1d5d53BsyBpAFBKFQvjBwSzfPLvAKxq3BGfzAs8GrUQA8wMGkXl6MTLGnd3nMGzIGkAUEoVC0PaBRJcPY1sEXZXr8ehLvcy8s9lVEpPY1HgLezU6RsKnPYBKKWKjebJB/Fo1IgqNauS4lOJD297gD3V6hId0EynbygE+gSglCo+tm+HNm2c0zR8EzKYb0IGO3fr9A0FS58AlFLFQ1oa7NkDrVtfcZoGnb6hYGkAUEoVD7t22ZZtbNPGbRdpL2qaAlJKFQ/bt9s+27RhSGMd4lkUNAAopYqH7duhfHlo2BDQIZ5FQVNASqniYft2aN0aPLRZKir6m1ZKuZ4xFwOAKjIaAJRSLhUencjgV36Ekyf58Fg5XbC9CGkfgFKqQDmWZby08zav7QATw2LosDcOgI2+gUzTN36LjAYApVSBcczp/+C6H9leuwmRtGZiWAxRh07x05ZE0i+kY8SDRIuViWExlPP2wJqRRbPkgwDE1QhyvvGrAaDwaQpIKVVgQiPi8Tx7hgm/f8tzf8wBwJqRxZzIw1gzspgW9g7zvp9AuYzzWDOySEnLwDsrg4G7/yCxYg1O+1QE9I3foqIBQClVYJIsVtolxeFpsul4eCe+F9IAyDKGGmdT6LUvik4JO/l/iz9ETDYYwzsRn3FrUjyhtz/kPI++8Vs0NAWklCowAX4+hCTEAuCdnUX3g9EsDe6Gpwh99kbigWFOm/7ct30Zh9Z8R2pZX0bGLGdq11GEt+wF6Bu/RUkDgFKqwIwfEIz/l7HEVa9P7TMn6L1vM7+36sE97QPpNz+Svyr7M3Hgs2R7ePDUxvkALGzegw+7PwDo2r1FTQOAUqrADGntT+ax3Sy4pR97LKfoc2ALZYa0ZEhTP7L+2s6PHe4CEd7o+3eqpqXieyGN8Xe+ACIIsH5Cb1f/FdyKBgClVMHZvh0vaxr3PDcSMjPhoYcYYo5BRCSe6RcY9e6z/HdDFokWK/8Y+nKuQzXvX/Q0ACilbkqe4/3Xr7ft7NYNfHxABBYvhr17oVo16NaN8ZWOMTEsBmtGlvNcmvd3DQ0ASqmruuILXD9t58H181ka3JXD1GJiWAwhm1ZQp04dqFcPgFOt2pE8bRa1Th5hfctupMcc08XcixENAEqpKwqPTmTy7D94Z8EHvNvrMQ4S6HyBq/2eLbzy2wz67o1k5P1TsGZk4R25AQb2dh57qGorno/5zva9fgfW5njLVxt819P3AJRSVxQaEU+HPVH027uJcetmAzhf4Bq9dRFZ4kGnhJ3cHbuGgNTj+J9OtqV/7MdGNAgB4LxXGdYGtdN1fYsZDQBKqStKsli5NdE2T8+guHU0OGWbqK1eyhH67N3M552HE+PfiJdXz+C2A9EAPLLbm/DoRJIsVnbVbEBCpZqsbhiCtUw55zlV8ZCvACAifiIyX0TiRCRWRLqISFURWS4ie+yfVexlRUQ+FpG9IrJdRG4tmL+CUqqwBPj5cGtSHHHV65Ph6cU/Nv4IwBPbl5Dl4cF37QYxqe+T1D57kldWTeecdznW+AQwMSwGv/LeIMKIB97npTuey3VOVTzk9wlgKrDUGNMMuAWIBSYAK40xTYCV9u8AdwBN7H/GAJ/n89pKqUL20u31aHlsH6sbdWDOLQMYunM1rSwJjNqxgqP978K7bh221GlBWMteVEpPIzogmCwPT6wZWRhjG91zpFINUsv5Ajrap7i56QAgIpWAHsB0AGNMujHGAgwGZtqLzQSG2H8eDHxnbDYCfiJS+6ZrrpQqdH/LOop3dhYHm97CVx2HAcJXc1/D+2wqbzfoy/gBwQgw5faHsZTzZU2Diw/2p60ZTB7WmkA/HwTbW76Th7XWzt9iJD+jgBoCycA3InILsAV4HvA3xhwBMMYcEZGa9vKBwOEcxyfYtx3JeVIRGYPtCYF69qFkSikX2bABgPc/GEN4YgYLNvRh+LYI/qzVhGUVg1hrT/Ucpxrd/j6DNHueH2ypHh3tU7zlJwXkBdwKfG6MaQec42K6Jy+SxzZz2QZjphljQowxITVq1MhH9ZRSVxMenUi3KatoMGEx3aasynslrg0boFEjqFmT0Ih4/tvxHs6W8eGLTveASK5Uz7my5TFia1I01VMy5CcAJAAJxphI+/f52ALCMUdqx/55PEf5ujmOrwMk5eP6Sqmb5Fi4pdLunXy84H1OHU9hYlhM7iBgjC0AdOkC2EbvHKoSwC3Pz2VJs+7OYprqKbluOgVkjDkqIodFJNgYEw/0AXbZ/4wGptg/F9gPWQg8IyJzgU7AaUeqSClVtEIj4rFmZHHv9uXcHbeWrYHN+CZkcO6VuA4ehKNHoWtXwJbSSbRYyfLwzHUuTfWUXPkdBfQsMFtEtgNtgfewNfz9RGQP0M/+HeBXYD+wF/gKeCqf11ZK3STHWPyuh/4E4IlNP+OdlZF7jL49/+94Ahg/IBgf79yNv6Z6SrZ8TQVhjNkGhOSxq08eZQ3wdH6up5QqGAF+PqQnJBF84i/+qNeGrn9tZ/Cu39lw290XC23YABUqQKtWADqHTymkcwEp5YbGDwhm3VsRAEzp+TBTlv6Xf0T+RPe3xjknf/t8/lIy/JtwOMcEbprqKV10Kgil3NCQdoE8w1+klvNlp38jZt42ikYnD7Pk3S8YO28bp46n0OLYfv7wD768c1iVGvoEoJSbCtq2Ee7ox/+7rz2vzvfkH361Gbt2Nt0PbqPbwW14mWy2BDZzTuCmd/6ljz4BKOWO9u+3jfLp04fQiHjOZsFnnUfQ7MQhhu5czYGqgUzqM4a19jd7dQK30kmfAJRyRytX2j579yZp5n4AfmjTjy2BzTlUpTaZnrmbBp3ArXTSAKBUKRQencjHi/4kNTmFsoG1Lx+ts3Il1K4NzZoR4HeERIsVRNhXve5l59KhnqWXBgClShnHW76vL5zKwN0b6Pv450wMS3fuD10ax4JFS4lq2oHz25IYPyD4sjV6Bds8LYE61LNU0wCgVCkTGhHP+fQM+u2NpMr5M7y66mvG3v0ikxbu5EJmNvWS9lE97TQrAlqxOCyGycNaM3lYax3f74Y0AChVyiRZrLQ+upfqaafZ4d+Iobt+46dWfVjXoB2e2Vk8GfkTAH/Ub+Mc4bN+Qm9t8N2QjgJSqpQJ8POh174oshEeu+c19lUN5N1ln1Il7TTTwt5h2M7VTO06iqRKtpnadYSP+9IAoFQpM35AML0PbGFbQFOOVazOq/2fpr7lKL9PG0PP/Vt4pf9TfHjbg87yOsLHfWkKSKkSzDFtQ67cfaA35shuvu4zGoAN9dswp01/Bsf+zphhr7CycSfn8TrCx72JbY624ikkJMRERUW5uhpKFUuO0T7PrphO5fNneaX/0/iU8WJWmXjav/4CREXR4MejGEBMNr7pVs6UreA8Xkf4lF4issUYk9dEnbnoE4BSJVRoRDzlTp/i8U3hlMnOZFfNhsxudyenFi4Af39o146A5b+RaLFixOOyxn/9hN4urL0qDrQPQKkSKsliZfCu3ymTncnOmg15ddV0miYfpMPuzSyu05bwP4/oHP7qqjQAKFVCBfj5MCJmBTH+jXh4xJukeZdl9rxX8Tt/lsV12jExLAZAl2tUV6QpIKVKqHeCMml5fD+v932SZN8qvHTH83wd9jaZ4sG6oLY6xl9dkwYApYqpPEf45GjIe21YTJZ3GTZ1GQjpsKJJJz7pci9VrKmklvMFdIy/ujoNAEoVQ+HRibz805+8vmgq+6rW4euOQ5wpHYAPF+/g56++JbpZV/4+tAOhEfEkWqx80OOhXOfRMf7qajQAKFUMhUbE0+/PVYzavgyATodjGHfXP3lh3jYEGBC/nqrWVL5r1otNYTHc0z6Qn7Yk5prQTTt71bVoAFCqGDpxIpUX185ih38jfmzdl1dWTWfxt8/za3A3Ak8fp31iLEd8q7E2qC3ZGVmsjkvWCd3UDdMAoFQx9HTcMuqePsaEgc+yPqgt22s14eNFoTy8ZSGJlWqyp3o95twygGwP2xDPJItVF2xXN0wDgFLFSHh0Ip+Hb2HuylmsCWrH+qC2AEQHNqPHk18BYOTy0dua61c3QwOAUi4WHp1I6NI4Tpw4TaULafw9cj6Vz59lSs9HnAuzQN4NP2iuX908DQBKuVD41gQ2vfEfwld9Q400i3N7WMte7PJvCICfjzcXMrN1xS5V4DQAKOUC4dGJfD97Fc/P/4D3Dm1nU50WzOgwmDNlK2Ap58vyJp2dZU9bM/hwZFvt4FUFTgOAUkUsPDqReR//wMxZE8nw8OTlAU8z55YBV0zxBPj5aAevKhQaAJQqYt/NXcOXP7zFMd+qjLx/MscqVr9iWc3vq8KU78ngRMRTRKJF5Bf79wYiEikie0RknoiUsW8va/++174/KL/XVqokCY9OpN+kRbw3YyJlszJ4bPjreTb+Yv/UidtUYSuIJ4DngVigkv37+8CHxpi5IvIF8Bjwuf0zxRjTWERG2cuNLIDrK1XshUcn8sr8bXw8720anzzM6HvfYl+1upeV005dVZTy9QQgInWAQcDX9u8C9Abm24vMBIbYfx5s/459fx97eaVKvdCIeO6NXECffZuZ1O/vzvH9Dj7ennw0sq3O3KmKVH5TQB8B/wKy7d+rARZjTKb9ewLg+NccCBwGsO8/bS+fi4iMEZEoEYlKTk7OZ/WUKh6y/zrMP9fO4rcG7ZnV9o5c+zTVo1zlplNAInIXcNwYs0VEejo251HUXMe+ixuMmQZMA9uawDdbP6WKyrWmbQaYvGY6XtlZvNb/H5DjwVeXZlSulJ8+gG7A30TkTqActj6AjwA/EfGy3+XXAZLs5ROAukCCiHgBlYFT+bi+Ui7nWJjd+8xp2p5MIJpmuaZtDo2Ip3nUb3y9cy0f9BzNYb9azn06wke52k0HAGPMRGAigP0J4EVjzAMi8iMwHJgLjAYW2A9ZaP++wb5/lTFG7/BVieS4609MSWPg7j94a/kX1DyXwsPDJ/FboxAmLdzJhcxs5NxZJi3/gt3V6jGj41CqlPfGkpahL3OpYqEw3gN4CZgrIu8A0cB0+/bpwP9EZC+2O/9RhXBtpQqd466/3OlTfLn0vwzYs5Ed/o04W8aHd5Z9Rv/HPsUCYAwfRXxCQOoJ7n1gCmniRZUyXkS/3t/VfwWlgAIKAMaY34Df7D/vBzrmUeY8MKIgrqeUK4VGxGPNyOLt1TPouT+K93o+wvQOQ2iXFMf82S8xbu0s3unzBKO3/sKQXb/zwW0PElWnJaBLNKriRd8EVuoGJVms1Dibwt2xvzP3lgFM63QPAFF1WjK77UAe2bKIhMr+vLJ6Ossbd+TTLvc6j9Vpm1Vxku83gZVyNwF+Pjyw7VfKZmXybfu/5do3pecjnKjgx6SV00ioXJN/DhrnnONHO31VcaMBQKkb9FLP+jy4bQkrG3XgQFVbJ66Pt21lrjNlKzBh4LPsq1qHvw99hdRyvoCO9VfFk6aAlLpBf4tbC+csLOw5AgHniJ7QiHgSLVZWN+rA6kYdnOV1rL8qrjQAKHUVOV/yquzjjWCY/dlblPVvQK+n7mPqrXVylZ8YFpNr4RZN+6jiTAOAUlfgGO5ZNjWF3omxlM3MoL7lCC2OH+BfA59j0c87QMSZ1nF86sItqqTQAKDUFTiGe376y3/ovT/Kuf2Yb1UWtLidCxlZhEbE52rgdeEWVZJoAFDqCpIsVhqcSqT3/iimhwxmbpv+XPAqw4kKflzwLusso1RJpQFAqSsI8PPhoRW/kO7hxRedhpPsWyXPMkqVVDoMVKkrmNg9kBExK1jcrHuejb928KqSTp8AlOIKUzpvWw7pVhbbh3tW9vFGBJ3MTZUaUpwn5AwJCTFRUVHXLqjUJcKjEwldGkfS6fPXbKwdo31yDt/0MNks//opzpf3Zc/CFdrQqxJFRLYYY0KuVU6fAFSpEx6dyHvfb2DRF0/yaecRfNf+bucc/Xk15I7RPvdvW8ItSbvZ6d8QARqdSuD5rv9k2VWOVaok0wCgSp3QiHgGRS/D/+wpXlzzPxY3u42TFfwuG7LpkGSxMmrbUt6L+JSzZXwYGbMcgOQKfvzarDsZeQz3VKqrkGC9AAARvUlEQVQ00ACgSp0jKef4v62L2Ve1DvUsRxi3bhavDHjmsiGbjrx/twPRvLPsM35r0J7Hhr9O9XMptDq2j6RKNcjw9AZ0uKcqnTQAqFJncPIuGqYk8dzd42mXFMdDWxfz3a13EV8jiLZvLkMEUtIyEKBx8iE+C5/Mnur1eGbwS2R5eHKsYnWOVaye65w63FOVRjoMVJU6L+1dQXKFKiwJ7spH3e7nTNnyvLbyKzAGizWDlHPphCTs5N+LP2LB/8Zx3rssjw1/nbNlywMgl5xPh3uq0kqfAFSpER6dyOw5q5m3diVf9bgP34rlSUnz5qNu9zNp5TTmzZmI74U0ap49RY00C2fL+BDeoifTOg4jqVJNwNb4fziyrc7no9yCBgBVKjiGcr7w+89kizCjVX/OZ2QDMKvdndx2MJrq5ywcrViNHf6NiKrTgsXNupNWJndqJ8DPR+fzUW5DA4AqFUIj4ql46jgjty9jadOuthx+RhaeImR6evHY8DeueQ5N9Sh3owFAlWiOkTyeB/YzZ96reGVn8VmONXizjMHH2zPXS145CWCwLdqiqR7lbjQAqBLLkfapm7SPWfNewzsrk/tHvcsu/4bOMoE5VutyLuqi0zkoBWgAUCVYaEQ8zQ/uYMb8N7ngVYZ775/Cnhr1nfsdKR3N6SuVNw0Aqti7dKK2Xs1qsDoumSZb1vB5+BSO+Vbl/0a+zWG/Ws5jNKWj1LVpAFDFkqPRT7RYEaDGmZPckRjLmbLl2RrvR7eje3kv4hPiajbg4RGTOFHh4nTNugi7UtdHA4AqNi5t9GunHmf0nkjujFtHh4RdeJB75tr19dvw5NBXnS9wgY7kUepGaABQxYKjQ7dMqoUXN/9Mn72baJ58EIC46vX5qPv9/NawPd5ZmVQ/Z6FMVgYRTbuS7uXtPIemfZS6MTcdAESkLvAdUAvIBqYZY6aKSFVgHhAEHATuNcakiIgAU4E7gTTgYWPM1vxVX5UWjimZpy6ZSp+9m9hcpwXv9HqUVY06sr9anWser2kfpW5cfp4AMoF/GmO2ikhFYIuILAceBlYaY6aIyARgAvAScAfQxP6nE/C5/VO5gTxX3Mpxp55ksdJnbyT992xkcs+H+bLT8Os+t6Z9lLo5Nx0AjDFHgCP2n8+ISCwQCAwGetqLzQR+wxYABgPfGdsSZBtFxE9EatvPo0qJvBp6gFfmb2P4pkVUSLfyWecRzgVawHb3Xy79PG8u/5Ld1eoxI2TwZefN+cKWYxSQztWjVP4USB+AiAQB7YBIwN/RqBtjjohITXuxQOBwjsMS7Ns0AJQSjjz+hQvpeJlsEi0wdt426qUk8e3ij+iQuAuATA9PpnW6h0kLd3IhMxtrRhbjN8yjTupx7r1/inMOfn1LV6nCle8AICK+wE/AC8aYVFuqP++ieWy7bEFiERkDjAGoV69efqunioDjrv/oqbOM2L6cF9Z/T/VzFg77+XPIL4COCTvI9PBi3KCx9N4XxYTfvuVglQCWNe0CQNukeJ7Y9DPzW/VhU91WgDb6ShWFfAUAEfHG1vjPNsaE2Tcfc6R2RKQ2cNy+PQGom+PwOkDSpec0xkwDpoFtUfj81E8VPsddf/vdUXy7chpNTh5mS0AzfmzdjwanEml0KoE1DW5lUp8nOVqpOouDu1Pn9DE++uUD3un9OAPj/6DHwWiSy/sxuecjgO1OQTt0lSp8+RkFJMB0INYY858cuxYCo4Ep9s8FObY/IyJzsXX+ntb8f8mSV34/NCKelge2M2P+mxz28+fJoS8T0aQLXOFJ8IJ3WZ4Y9ho//28c70V8ylHfqvy7x0N833YgFp9KgK6+pVRREVuf7E0cKNIdWAvEYBsGCvAytn6AH4B6wF/ACGPMKXvA+AQYiG0Y6CPGmKirXSMkJMRERV21iCoijjv923esYX/VQHbXCEKAWqnJLJw5ljNlyzPkof+QWs73us5Xx3KUlsf3s7JRRzI9L96H+Hh7MnlYa039KJUPIrLFGBNyrXL5GQW0jrzz+gB98ihvgKdv9nrKtUIj4umxYy1fhE8mUzz4tv3dfNF5OF/+/C7lMi8w6r7JlzX+jk5cBx9vT8p5e5CSlkGCXy0ScszdA5r3V6qo6ZvA6rqkJyQxOeITYvwbsb12Ex6NWshDWxfjlZ3FE/e8yr7qF7t3HHfxQJ5DQieGxeSan1/v+pVyDQ0A6qrCoxMJXRrH+0umUj7jPC/c9SL7qtdlXpv+/Ov3maxo3ImVjS++z3fpXfyVGnVdc1cp17vpPoCioH0AruXI+w/d/AvvRXzKG32fZGb7u69YXqdjUKp4KPQ+AFWyXWtqBrDdpbfdu5XXVn7NmqB2fHfrIOe+vPL7Oh2DUiWLh6sroIqe484+0WLFAIkWKxPDYgiPTnTu7zZlFU23rOHbHyfxl58/4+4ahxHbPxcBPhzZlkA/HwTbnb/m8JUqefQJwA05Zt7suS+Kpzf8wOSej7C1TnNCI+IBWydtr5jfmboolNiaDXjo3recY/TBNk5fl1lUquTTJwA34rizT0xJ48nI+cyY/ya3JsUx64dX6XZwG4kWKy9+H8XTK7/hkwXvEx0QzAOj3s3V+GuqR6nSQ58ASqErzcg5MSyGbKuVqb9OZXDs7yxqdhv/vn00X/30NjPmT+KtPmMYEbOCtkd2M7dNfyb1HcN573LO8+o4faVKFx0FVEpcupyi74Vz1LUcY5d/w4svYJ1L5+NFofwtdg3/7vEQn3UeASJUtp5h5o+v0/bIHizlfJkw8FmWBnfLdX4d4aNUyaGjgNyIo1PXmpFFmcwMHoz+lWc2zKOqNZUPbnuQT7qMxJohPL3hB/4Wu4b3bx/N551HOI8/7VORB0a+ywPblrCoeQ+OVKqR6/ya9lGqdNIAUMJcaUI2a0YW7RLj+HhRKHVPH2Nt/bZYfCry4tpZ1E85yupGIYxf+z9+btGTz3OsthVon3gt0QLTOt1z2fU07aNU6aUBoATJeacPF4dvWjOy8MzOIvTXjxCTzYP3vs26Bu3AGPZWq8vY9d8zYscKttVuyoSBzzpn6sx5Z6/TMyjlfjQAlAA58/vVzll4d/V0PLOzGXfXOKwZ4CnCyO3LaHwqgSeGvWpr/AFEmNr9fg5Vqc09MSsZd9c4LniXBfK+s9fpGZRyLxoAijnnXX96Jn+LXcOkFV9S8cI5vLOzOFKxGlN6PUrZC2mMXTebyDotWW6flyfnm7rhLXsR3rKX85x5dejquH6l3I8GgGIuNCIea3omk5f+l/u2LyO6djDj73yeh7Yu5u+bwoip1YTGJw9T45yFMcNeAxHn3T3kndrRDl2lFGgAKLZypn3u+zOC+7Yv44uOw/j37aPJ9vDk7T6P0/z4AUKXfIRB+CW4O9EBwXne3WtqRymVFw0ALnCtidhydvY2P76fSSu+ZE1QO97v+bBzPp4MT2+eGjKBX2a+QNW004Te/hAASRZrrmtpakcpdSX6IlgRu3QkD1zM1/v5eCMCKWkZAFS4kMbC78bim27lzoc/5mQFPyD3ylr1U5IISD3BhvptAH1hSymlL4IVCznv9Ctf0rjjCLwizs5aizXDeWzg6eO8F/EJQSlHuH/Uu87G/9L8/qEqARyqEgBofl8pdWM0ABSSS+/0HY17QOpxxkSGMWr7MnZXr8eXHe9haXBXsjw8AahsPcM/IufzSNRCjAhv9H2SyHq25RU1v6+UKkgaAK5TXnfzlrSMqy6mYs3IotL5szRLPkhw8kFuTYzjrri1APwa3J1Wx/by6cL3OeRXi2O+ValvOYr/2VNkI/zcqhcf3PZ/zmkZ8rq71/y+Uio/tA/gElebSTNn3j4nRw4/0M+HXs1qsDoumUSLlaE7VjFl6ceUzcoEwFLOl59b9uKrjkNJqlQTj+ws+u2N5KGtv+CVnc0hv1r85VeLlY07EluzofP8Oh2DUupGXG8fgAaAHK7WQXtDjOGpjT/yrzXf8Ue9NnzZ6R7iatTnmG815zQM13N+nY5BKXUztBP4Gq7aQZtDzsZ56I5VPBj9K4Ih08MTq3c5ttVuypbA5uz0b0Tl82epdeYEg3f9zsiY5fzcoif/uvN5Mjy9Lzuvo3EHbii1pJRSBcWtAsClc+bnNfoGYxi5fRkhCbH80vw21jRoh0/GBd5e/jn37FhFbI0gkitUwdNkUf2chac3/ICXyb7sWp91Hs6/e4x23vH7XaVx10ZeKeUKbhMALk3v5JV28Uk/z7vLPmXYztWc9yrDiB0rSKhUkwxPT+qnHOWjbvfxcddRZNtH7ACUT7fSNimeZsmHOFW+EkcqVuewnz9JlWo6y+jYfKVUcVQqA8DV0juVzp+l5/4tdD30J10P/YlP5gV2+Dcixr8x/fdspOmJv/jgtgf5quMw+u6J5P4/l1DjrIUHRr3rfNkq5wtb1jI+/BHUlj+C2uZZFx2br5QqrkpdJ3BeHbkOXQ9uY+qiD6iRZuF02QpsrNeaM2Ur0OroXpqcPMzpcr68cNc/WdOwPXB5B21enbKXjhpyjALSsflKKVcptp3AIjIQmAp4Al8bY6YU5Pkd4+9zXdNk89SGHxm3bjb7qwby96EvEx0QnCuV45N+nmwPDy54lcmzg/ZKjbmOxVdKlVRFGgBExBP4FOgHJACbRWShMWZXQV3DMRnagpljqWJNJcvDA++sTOqkJhPe4nZeHvAMaWVsyyDmmoOnvDeWtIzLxtxr466UKq2K+gmgI7DXGLMfQETmAoOBAgsAAX4+JFqsbA1sRuXzZ/HMzsbTZDO123382Lqfc1SOvlyllHJ3RR0AAoHDOb4nAJ0K8gLjBwQzMSyGN/s+med+fblKKaVsijoASB7bcvVCi8gYYAxAvXr1bvgCjoZdX65SSqmrK+oAkADUzfG9DpCUs4AxZhowDWyjgG7mItoxq5RS1+ZRxNfbDDQRkQYiUgYYBSws4joopZSiiJ8AjDGZIvIMEIFtGOgMY8zOoqyDUkopmyJ/D8AY8yvwa1FfVymlVG5FnQJSSilVTGgAUEopN6UBQCml3FSxngxORJKBQ66uRwGoDpxwdSWKCf1d5Ka/j4v0d5Fbfn4f9Y0xNa5VqFgHgNJCRKKuZ2Y+d6C/i9z093GR/i5yK4rfh6aAlFLKTWkAUEopN6UBoGhMc3UFihH9XeSmv4+L9HeRW6H/PrQPQCml3JQ+ASillJvSAFBIRKSuiKwWkVgR2Skiz7u6Tq4mIp4iEi0iv7i6Lq4mIn4iMl9E4uz/Rrq4uk6uJCJj7f9PdojIHBEp5+o6FRURmSEix0VkR45tVUVkuYjssX9WKYxrawAoPJnAP40xzYHOwNMi0sLFdXK154FYV1eimJgKLDXGNANuwY1/LyISCDwHhBhjWmGbKHKUa2tVpL4FBl6ybQKw0hjTBFhp/17gNAAUEmPMEWPMVvvPZ7D9B3fbRQpEpA4wCPja1XVxNRGpBPQApgMYY9KNMRbX1srlvAAfEfECynPJOiGlmTFmDXDqks2DgZn2n2cCQwrj2hoAioCIBAHtgEjX1sSlPgL+BWS7uiLFQEMgGfjGnhL7WkQquLpSrmKMSQQ+AP4CjgCnjTHLXFsrl/M3xhwB280kULMwLqIBoJCJiC/wE/CCMSbV1fVxBRG5CzhujNni6roUE17ArcDnxph2wDkK6RG/JLDntwcDDYAAoIKIPOjaWrkHDQCFSES8sTX+s40xYa6ujwt1A/4mIgeBuUBvEZnl2iq5VAKQYIxxPBHOxxYQ3FVf4IAxJtkYkwGEAV1dXCdXOyYitQHsn8cL4yIaAAqJiAi2HG+sMeY/rq6PKxljJhpj6hhjgrB17q0yxrjtHZ4x5ihwWESC7Zv6ALtcWCVX+wvoLCLl7f9v+uDGneJ2C4HR9p9HAwsK4yJFviKYG+kG/B8QIyLb7Ntetq+IptSzwGz72tj7gUdcXB+XMcZEish8YCu20XPRuNFbwSIyB+gJVBeRBOANYArwg4g8hi1AjiiUa+ubwEop5Z40BaSUUm5KA4BSSrkpDQBKKeWmNAAopZSb0gCglFJuSgOAUkq5KQ0ASinlpjQAKKWUm/r/Rv5OIbzutNEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1f0a9aee9b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = FFM(epochs=10)\n",
    "train_losses,eval_losses = model.fit(X_train, y_train, eval_set=(X_test,y_test))\n",
    "plt.scatter(data[:, 0], target)\n",
    "plt.plot(data[:, 0], model.predict(data), color='r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### tweedie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1f09617e470>]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1f0abba4f98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = FFM(epochs=10,objective='tweedie')\n",
    "train_losses,eval_losses = model.fit(X_train, y_train, eval_set=(X_test,y_test))\n",
    "plt.scatter(data[:, 0], target)\n",
    "plt.plot(data[:, 0], model.predict(data), color='r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### poisson"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1f0abc2c198>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1f0a9b57fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = FFM(epochs=10,objective='poisson')\n",
    "train_losses,eval_losses = model.fit(X_train, y_train, eval_set=(X_test,y_test))\n",
    "plt.scatter(data[:, 0], target)\n",
    "plt.plot(data[:, 0], model.predict(data), color='r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### gamma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1f0abb964e0>]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1f098824dd8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = FFM(epochs=10,objective='gamma')\n",
    "train_losses,eval_losses = model.fit(X_train, y_train, eval_set=(X_test,y_test))\n",
    "plt.scatter(data[:, 0], target)\n",
    "plt.plot(data[:, 0], model.predict(data), color='r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import make_classification\n",
    "data, target = make_classification(n_samples=200, n_features=2, n_classes=2, n_informative=1, n_redundant=0,\n",
    "                                   n_repeated=0, n_clusters_per_class=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 二分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1f0abc9ea20>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ffm=FFM(epochs=10, solver='adam',objective='logistic')\n",
    "ffm.fit(data,target)\n",
    "utils.plot_decision_function(data,target,ffm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 多分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets.samples_generator import make_blobs\n",
    "X, y = make_blobs(n_samples=400, centers=4, cluster_std=0.85, random_state=0)\n",
    "X = X[:, ::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1f0abdf1198>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from ml_models.wrapper_models import *\n",
    "ffm=FFM(epochs=10, solver='adam',objective='logistic')\n",
    "ovr = MultiClassWrapper(ffm, mode='ovr')\n",
    "ovr.fit(X, y)\n",
    "utils.plot_decision_function(X,y,ovr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
